home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48_2 / areuh.tar / areuh / assembler / aopc1.c < prev    next >
C/C++ Source or Header  |  1990-10-10  |  12KB  |  631 lines
  1. /*
  2.  * Authors :
  3.  *   Pierre DAVID (pda@masi.ibp.fr or pda@frunip62.bitnet)
  4.  *   Janick TAILLANDIER
  5.  *
  6.  * This program can be freely used or distributed as long as this
  7.  * note is kept.
  8.  *
  9.  * This program is provided "as is".
  10.  */
  11.  
  12. /******************************************************************************
  13.  
  14.                  AREUH ASSEMBLER
  15.  
  16.                 OPCODE PROCESSING (PART 1)
  17.  
  18.  
  19. ******************************************************************************/
  20.  
  21. #include "aglobal.h"
  22. #include "agen.h"
  23.  
  24. #define UPRC(c)   ((((c)>='a')&&((c)<='z')) ? (c)-32 : (c))
  25.  
  26. extern uchar *memoire() ;
  27. extern saddr calc_expression () ;
  28. extern uchar hex () ;
  29.  
  30.  
  31. /******************************************************************************
  32.  
  33.                   ADD_XUSED
  34.  
  35.  
  36. synopsis : void add_xused (type, pc, len, exp)
  37.        int type, len
  38.        saddr pc
  39.        uchar *exp
  40. description : adds the parameters about the use of an expression containing
  41.           external references.
  42.  
  43. ******************************************************************************/
  44.  
  45. void add_xused (type, addr, len, exp)
  46. int type, len ;
  47. saddr addr ;
  48. uchar *exp ;
  49. {
  50.     struct xused *xu ;
  51.  
  52.     xu = (struct xused *) memoire (sizeof (struct xused)) ;
  53.     if (xu==(struct xused *) NULL)
  54.     error (ERRMEM, "") ;
  55.     xu->u_characteristic = (uchar) (type + len) ;
  56.     xu->u_pc = addr ;
  57.     xu->u_expression = memoire (strlen (exp) + 1) ;
  58.     if (xu->u_expression==(uchar *)NULL)
  59.     error (ERRMEM, "") ;
  60.     strcpy (xu->u_expression, exp) ;
  61.     xu->u_next = headxu ;     /* queue it */
  62.     headxu = xu ;          /* before the previous head */
  63. }
  64.  
  65.  
  66. /******************************************************************************
  67.  
  68.                   FIELD_SELECT
  69.  
  70.  
  71. synopsis : field_select (modif)
  72.        uchar *modif
  73. description : to be described, in a (far) future...
  74.  
  75. ******************************************************************************/
  76.  
  77. int field_select (modif)
  78. uchar *modif ;
  79. {
  80.     int r = 0 ;
  81.     char c ;
  82.  
  83.     switch (UPRC(*modif))
  84.     {
  85.     case 'P' :
  86.         r = 1 ;
  87.         break ;
  88.     case 'W' :
  89.         if (UPRC(modif[1])=='P')
  90.         {
  91.         r = 2 ;
  92.         modif++ ;
  93.         }
  94.         else r = 8 ;
  95.         break ;
  96.     case 'X' :
  97.         if (UPRC(modif[1])=='S')
  98.         {
  99.         r = 3 ;
  100.         modif++ ;
  101.         }
  102.         else r = 4 ;
  103.         break ;
  104.     case 'S' :
  105.         r = 5 ;
  106.         break ;
  107.     case 'M' :
  108.         r = 6 ;
  109.         break ;
  110.     case 'B' :
  111.         r = fs_B ;
  112.         break ;
  113.     case 'A' :
  114.         r = fs_A ;
  115.         break ;
  116.     }
  117.     c = *(++modif) ;
  118.     if ((c!=' ')&&(c!=EOL)&&(c!='\t')) r = 0 ;
  119.     return (r) ;
  120. }
  121.  
  122.  
  123. void regtest(ad, modif)
  124. struct mnemo_desc *ad ;
  125. uchar *modif ;
  126. {
  127.     int r ;
  128.  
  129.     if (r=field_select(modif) )
  130.     {
  131.     if (r==fs_A)
  132.     {
  133.         gen_code[1] = hex (r + ad->m_a) ;
  134.     }
  135.     else
  136.     {
  137.         gen_code[0] = '9' ;
  138.         gen_code[1] = hex ((ad->m_a==2) ? r+7 : r-1) ;
  139.     }
  140.     }
  141.     else error (WRNIWS, "") ;
  142. }
  143.  
  144.  
  145. void regarith (ad, modif)
  146. struct mnemo_desc *ad ;
  147. uchar *modif ;
  148. {
  149.     int r ;
  150.  
  151.     if (r=field_select(modif))
  152.     {
  153.     /* gen_len is 3 by default */
  154.     if (r==fs_A)   gen_len = 2 ;
  155.  
  156.     if (passnb==2)
  157.     {
  158.         if (r==fs_A)
  159.         {
  160.         gen_code[0] = hex (ad->m_a + 11) ;
  161.         gen_code[1] = gen_code[2] ;
  162.         gen_code[2] = EOL ;
  163.         }
  164.         else
  165.         {
  166.         gen_code[0] = hex(((ad->m_a==ar_C)||(ad->m_a==ar_D))?10:11) ;
  167.         gen_code[1] = hex(((ad->m_a==ar_C)||(ad->m_a==ar_E))?r-1:r+7) ;
  168.         }
  169.     }
  170.     }
  171.     else error (WRNIWS, "") ;
  172. }
  173.  
  174.  
  175. void reglogic (modif)
  176. uchar *modif ;
  177. {
  178.     int r ;
  179.  
  180.     if (r=field_select(modif))
  181.     gen_code[2] = (r==fs_A) ? 'F' : hex(r-1) ;
  182.     else error (WRNIWS, "") ;
  183. }
  184.  
  185.  
  186. int range (org, dest, nibs, offset)
  187. saddr org, dest, *offset ;
  188. int nibs ;
  189. {
  190.     saddr Sixtine, Fiftine ;
  191.     int r ;
  192.  
  193.     Sixtine = ((saddr) 1) << (nibs*4) ;
  194.     Fiftine = Sixtine >> 1 ;
  195.     *offset = dest - org ;
  196.     r = ((*offset >= -Fiftine) && (*offset < Fiftine)) ;
  197.     if (*offset<0)   (*offset) += Sixtine ;       /* -128 = 128 ; -1 = 255 */
  198.     return (r) ;
  199. }
  200.  
  201.  
  202. void branches (ad, modif)
  203. struct mnemo_desc *ad ;
  204. uchar *modif ;
  205. {
  206.     saddr val, offset, pc_bis ;
  207.     int fits, i, j ;
  208.     uchar hex_var[MAXLEN+1] ;
  209.  
  210.     if ((ad->m_flag & F_GOYS) && (!(prev_test)))
  211.     error (WRNTST, "") ;       /* needs previous test instruction */
  212.     else
  213.     {
  214.     val = calc_expression (modif) ;
  215.     if (val >= 0L)
  216.     {
  217.         if (ad->m_flag & F_ABSL)
  218.         {
  219.         fits = 1 ;
  220.         offset = val ;
  221.         }
  222.         else
  223.         {
  224.         if (ad->m_flag & F_GSUB) pc_bis = pc + (long int) gen_len ;
  225.         else pc_bis = pc + (long int) (ad->m_a) - 1L ;
  226.         fits = range (pc_bis, val, ad->m_b, &offset) ;
  227.         }
  228.  
  229.         if (!(fits))
  230.         {
  231.         offset = 0L ;
  232.         error (WRNJVL, "") ;       /* Jump or value too large */
  233.         }
  234.  
  235.         hex6 (hex_var, offset) ;
  236.         for (i=1, j=5; i<=ad->m_b; i++, j--)
  237.         {
  238.         gen_code[ad->m_a + i - 2] = hex_var[j] ;
  239.         }
  240.         gen_code[gen_len] = EOL ;
  241.     }
  242.     else           /* EXP_ERR or EXP_EXT */
  243.     {
  244.         if (val == EXP_EXT)
  245.         {
  246.         switch (ad->m_flag & (F_GSUB | F_ABSL))
  247.         {
  248.             case F_GSUB :
  249.             i = XRGSB ;
  250.             break ;
  251.             case F_ABSL :
  252.             case F_ABSL | F_GSUB :
  253.             i = XABSL ;
  254.             break ;
  255.             default :
  256.             i = XRGTO ;
  257.             break ;
  258.         }
  259.         add_xused (i, pc + (long int) ad->m_a - 1L, ad->m_b, extexp) ;
  260.         }
  261.         for (i=0; i<ad->m_b; i++) gen_code [ad->m_a - 1 + i] = '0' ;
  262.         gen_code [gen_len] = EOL ;
  263.     }
  264.     }
  265. }
  266.  
  267.  
  268. void rtnyes()
  269. {
  270.     if (!(prev_test))  error (WRNTST, "") ;   /* needs previous test instr. */
  271. }
  272.  
  273.  
  274. void ptrtest (modif)
  275. uchar *modif ;
  276. {
  277.     saddr val ;
  278.  
  279.     val = calc_expression (modif) ;
  280.     if (val == EXP_EXT)
  281.     {
  282.     add_xused (XABSL, pc + 2L, 1, extexp) ;
  283.     val = (saddr) 0 ;            /* FALLS INTO FOLLOWING */
  284.     }
  285.     if (val == EXP_ERR)
  286.     val = (saddr) 0 ;            /* FALLS INTO FOLLOWING */
  287.     if (val>15L)
  288.     error (WRNIPP, "") ;      /* illegal pointer position */
  289.     else gen_code[2] = hex ((int) val) ;
  290. }
  291.  
  292.  
  293. void stattest (modif)
  294. uchar *modif ;
  295. {
  296.     saddr val ;
  297.  
  298.     val = calc_expression (modif) ;
  299.     if (val == EXP_EXT)
  300.     {
  301.     add_xused (XABSL, pc + 2L, 1, extexp) ;
  302.     val = (saddr) 0 ;            /* FALLS INTO FOLLOWING */
  303.     }
  304.     if (val == EXP_ERR)
  305.         val = (saddr) 0 ;                /* FALLS INTO FOLLOWING */
  306.     if (val>15L)
  307.     error (WRNISB, "") ;      /* illegal status bit */
  308.     else gen_code[2] = hex ((int) val) ;
  309. }
  310.  
  311.  
  312. void setptr (modif)
  313. uchar *modif ;
  314. {
  315.     saddr val ;
  316.  
  317.     val = calc_expression (modif) ;
  318.     if (val == EXP_EXT)
  319.     {
  320.     add_xused (XABSL, pc + (long int) gen_len - 1L, 1, extexp) ;
  321.     val = (saddr) 0 ;
  322.     }                        /* FALLS INTO FOLLOWING */
  323.     if (val == EXP_ERR)
  324.     val = (saddr) 0 ;            /* FALLS INTO FOLLOWING */
  325.     if (val>15L)
  326.     error (WRNIPP, "") ;      /* illegal pointer position */
  327.     else gen_code[gen_len-1] = hex ((int) val) ;
  328. }
  329.  
  330.  
  331. void setstat (modif)
  332. uchar *modif ;
  333. {
  334.     saddr val ;
  335.  
  336.     val = calc_expression (modif) ;
  337.     if (val == EXP_EXT)
  338.     {
  339.     add_xused (XABSL, pc + 2L, 1, extexp) ;
  340.     val = (saddr) 0 ;
  341.     }                        /* FALLS INTO FOLLOWING */
  342.     if (val == EXP_ERR)
  343.     val = (saddr) 0 ;            /* FALLS INTO FOLLOWING */
  344.     if (val>15L)
  345.     error (WRNISB, "") ;      /* illegal status bit */
  346.     else gen_code[2] = hex ((int) val) ;
  347. }
  348.  
  349.  
  350. void dparith (modif)
  351. uchar *modif ;
  352. {
  353.     saddr val ;
  354.  
  355.     val = calc_expression (modif) ;
  356.     if (val >= 0L)
  357.     {
  358.     if ((val<1L)||(val>16L))
  359.         error (WRNIDP, "") ;      /* illegal dp arithmetic value */
  360.     else gen_code[2] = hex (val - 1L) ;
  361.     }
  362.     else if (val == EXP_EXT)
  363.     {
  364.     add_xused (XABSO, pc + 2L, 1, extexp) ;
  365.     val = (saddr) 1 ;
  366.     }
  367.     else         /* (val == EXP_ERR) */
  368.     {
  369.     val = (saddr) 1 ;
  370.     }
  371. }
  372.  
  373.  
  374. void datatrans (modif)
  375. uchar *modif ;
  376. {
  377.     saddr val ;
  378.     int r ;
  379.  
  380.     r=field_select (modif) ;
  381.     if ((r==fs_A)||(r==fs_B))  gen_len = 3 ;
  382.     if (passnb == 2)
  383.     {
  384.     switch (r)
  385.     {
  386.         case 0 :      /* expression instead of field selector */
  387.         val = calc_expression (modif) ;
  388.         if (val >= 0L)
  389.         {
  390.             if ((val<1L)||(val>16))
  391.             error (WRNTFR, "") ;  /* illegal transfer value */
  392.             else
  393.             {
  394.             gen_code[2] = hex (dec(gen_code[2])+8) ;
  395.             gen_code[3] = hex ((int) val - 1L) ;
  396.             }
  397.         }
  398.         else if (val == EXP_EXT)
  399.         {
  400.             add_xused (XABSO, pc + 3L, 1, extexp) ;
  401.             gen_code[2] = hex (dec(gen_code[2])+8) ;  /* ajout */
  402.             val = 1L ;
  403.         }
  404.         else         /* (val == EXP_EXT) */
  405.         {
  406.             val = 1L ;
  407.         }
  408.         break ;
  409.         case fs_A :
  410.         gen_len = 3 ;
  411.         gen_code[1] = '4' ;
  412.         gen_code[3] = EOL ;
  413.         break ;
  414.         case fs_B :
  415.         gen_len = 3 ;
  416.         gen_code[1] = '4' ;
  417.         gen_code[2] = hex ( dec(gen_code[2]) + 8) ;
  418.         gen_code[3] = EOL ;
  419.         break ;
  420.         default :
  421.         gen_code[3] = hex (r-1) ;
  422.         break ;
  423.     }
  424.     }
  425. }
  426.  
  427.  
  428. int hex_len (modif)      /* aCLCHX : AS5 : ED094 */
  429. uchar *modif ;
  430. {
  431.     int i = 0 ;
  432.  
  433.     if (*modif=='#') modif++ ;
  434.     while (((*modif>='0')&&(*modif<='9'))||
  435.        ((*modif>='A')&&(*modif<='F'))||
  436.        ((*modif>='a')&&(*modif<='f')))
  437.     {
  438.     modif++ ;
  439.     i++ ;
  440.     }
  441.     return ((i>16) ? 16 : i) ;
  442. }
  443.  
  444.  
  445. void check_last_hex (digit)
  446. uchar digit ;
  447. {
  448.     if ((digit!=EOL)&&(digit!='\t')&&(digit!=' '))
  449.     {
  450.     if ((digit<'0')||
  451.         ((digit>'9')&&(digit<'A'))||
  452.         ((digit>'F')&&(digit<'a'))||
  453.         (digit>'f'))
  454.         error (WRNTMH, "") ;   /* too many hex digit present    */
  455.     else error (WRNNHX, "") ;  /* non hexadecimal digit present */
  456.     }
  457. }
  458.  
  459.  
  460. void nibhex (modif)
  461. uchar *modif ;
  462. {
  463.     int i ;
  464.  
  465.     gen_len = hex_len (modif) ;
  466.     if (passnb==2)
  467.     {
  468.     if (*modif=='#') modif++ ;
  469.     for (i=0; i<gen_len; i++)
  470.     {
  471.         if (modif[i]>='a') gen_code[i] = modif[i] - 32 ;
  472.         else           gen_code[i] = modif[i] ;
  473.     }
  474.     gen_code[gen_len] = EOL ;
  475.     check_last_hex (modif[gen_len]) ;
  476.     }
  477. }
  478.  
  479.  
  480. void lchex (modif)
  481. uchar *modif ;
  482. {
  483.     int i, j ;
  484.  
  485.     gen_len = hex_len (modif) ;
  486.     if (passnb==2)
  487.     {
  488.     if (*modif=='#') modif++ ;
  489.     if (gen_len)
  490.     {
  491.         gen_code[1] = hex (gen_len - 1) ;
  492.         for (i=0, j=gen_len-1; i<gen_len; i++, j--)
  493.         {
  494.         if (modif[j]>='a') gen_code[2+i] = modif[j] - 32 ;
  495.         else           gen_code[2+i] = modif[j] ;
  496.         }
  497.         gen_code[gen_len + 2] = EOL ;
  498.         check_last_hex (modif[gen_len]) ;
  499.     }
  500.     else
  501.     {
  502.         gen_code[0] = EOL ;
  503.         error (WRNNHX, "") ; /* non hex present (in fact, there is no) */
  504.     }
  505.     }
  506.  
  507.     gen_len = (gen_len) ? gen_len+2 : 0 ;
  508. }
  509.  
  510.  
  511. void dxhex (modif)
  512. uchar *modif ;
  513. {
  514.     int i, j, r ;
  515.  
  516.     r = hex_len (modif) ;
  517.     if (passnb==2)
  518.     {
  519.     if ((r!=2)&&(r!=4)&&(r!=5))
  520.         error (WRNIHX, "") ;  /* illegal hex const (number of digits) */
  521.     else
  522.     {
  523.         if (*modif=='#') modif++ ;
  524.         /* if 2, no change to the opcode */
  525.         /* if 4, add 1, if 5 add two     */
  526.         if (r!=2) gen_code[1] = hex (dec(gen_code[1]) + r - 3) ;
  527.         for (i=0, j=r-1; i<r; i++, j--)
  528.         {
  529.         if (modif[j]>='a') gen_code[2+i] = modif[j] - 32 ;
  530.         else           gen_code[2+i] = modif[j] ;
  531.         }
  532.         gen_code[r+2] = EOL ;
  533.         check_last_hex (modif[r]) ;
  534.     }
  535.     }
  536.     gen_len = ((r==4)||(r==5)) ? r+2 : 4 ;
  537. }
  538.  
  539.  
  540. int ascii_len (modif)
  541. uchar *modif ;
  542. {
  543.     uchar limit ;
  544.     int i = 0 ;
  545.  
  546.     switch (*modif)
  547.     {
  548.     case '\'' :
  549.     case '\\' :
  550.         limit = *modif++ ;
  551.         while ((*modif!=limit)&&(*modif))
  552.         {
  553.         modif++ ;
  554.         i++ ;
  555.         }
  556.         break ;
  557.     }
  558.     return ((i>8) ? 8 : i) ;
  559. }
  560.  
  561.  
  562. void nibasc (modif)
  563. uchar *modif ;
  564. {
  565.     uchar limit ;
  566.     int i ;
  567.  
  568.     gen_len = ascii_len (modif) ;
  569.     if (passnb==2)
  570.     {
  571.     limit = *modif ;
  572.     for (i=1; i<=gen_len; i++)
  573.     {
  574.         gen_code[2*(i-1)] = hex (((int) modif[i]) % 16) ;
  575.         gen_code[2*i-1] = hex (((int) modif[i]) / 16) ;
  576.     }
  577.     gen_code[2*gen_len] = EOL ;
  578.     switch (modif[gen_len + 1])
  579.     {
  580.         case '\'' :
  581.         case '\\' :
  582.         if (modif[gen_len + 1]!=limit)
  583.             error  (WRNTMA, "") ; /* too many ascii chars present */
  584.         break ;
  585.         case EOL :
  586.         error (WRNASC, "") ;      /* illegal ascii constant       */
  587.         break ;
  588.         default :
  589.         error (WRNTMA, "") ;      /* too many ascii chars present */
  590.         break ;
  591.     }
  592.     }
  593.     gen_len *= 2 ;
  594. }
  595.  
  596.  
  597. void lcasc (modif)
  598. uchar *modif ;
  599. {
  600.     uchar limit ;
  601.     int i ;
  602.  
  603.     gen_len = ascii_len (modif) ;
  604.     if (passnb==2)
  605.     {
  606.     limit = *modif ;
  607.     for (i=1; i<=gen_len; i++)
  608.     {
  609.         gen_code[2*i]   = hex (((int) modif[gen_len - i + 1]) % 16) ;
  610.         gen_code[2*i+1] = hex (((int) modif[gen_len - i + 1]) / 16) ;
  611.     }
  612.     gen_code[2+2*gen_len] = EOL ;
  613.     switch (modif[gen_len + 1])
  614.     {
  615.         case '\'' :
  616.         case '\\' :
  617.         if (modif[gen_len + 1]!=limit)
  618.             error  (WRNTMA, "") ; /* too many ascii chars present */
  619.         break ;
  620.         case EOL :
  621.         error (WRNASC, "") ;      /* illegal ascii constant       */
  622.         break ;
  623.         default :
  624.         error (WRNTMA, "") ;      /* too many ascii chars present */
  625.         break ;
  626.     }
  627.     gen_code[1] = hex (2*gen_len - 1) ;
  628.     }
  629.     gen_len = (gen_len) ? 2+2*gen_len : 0 ;
  630. }
  631.